#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <cstdio>
#include <queue>
#include<iomanip>
#include <map>
#include <string>
using namespace std;
#define int long long


string s;
void solve() {
    cin >> s;
    vector<int> e[26];
    for (int i = 0; i < s.size(); i++) {
        e[s[i] - 'a'].push_back(i);
    }
    string ans = s;
    for (int i = 0; i < 26; i++) {
        bool ok = false;
        if (e[i].size()) {
            for (int v = 0; v < e[i].size(); v++) {
                string tmp = s.substr(0, e[i][v] + 1);
                reverse(tmp.begin(), tmp.end());
                string cur = ans.substr(0, e[i][v] + 1);
                if (tmp < cur) {
                    ans = tmp + s.substr(e[i][v] + 1);
                    ok = true;
                }
            }
        }
        if (ok) {
            cout << ans << '\n';
            return;
        }
    }
}


signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    int tt;
    cin >> tt;
    while (tt--) solve();
    return 0;
}
//void solve() {
//    int n;
//    cin >> n;
//    vector<int> p = { 1, 6, 28, 88, 198, 328, 648 };
//    vector<int> base = { 10, 60, 280, 880, 1980, 3280, 6480 };
//    vector<int> bonus = { 8, 18, 28, 58, 128, 198, 388 };
//
//    int m = p.size();
//    vector<int> dp(n + 1, 0);
//    for (int j = 0; j < m; j++) {
//        for (int i = n; i >= p[j]; i--) {
//            dp[i] = max(dp[i], dp[i - p[j]] + base[j] + bonus[j]);
//        }
//        for (int i = p[j]; i <= n; i++) {
//            dp[i] = max(dp[i], dp[i - p[j]] + base[j]);
//        }
//    }
//
//    cout << dp[n] << '\n';
//}



//if (n >= 198) {
//    n -= 198;
//    ans += 128;
//}
//if (n >= 88) {
//    n -= 88;
//    ans += 58;
//}
//if (n >= 28) {
//    n -= 28;
//    ans += 28;
//}
//if (n >= 6) {
//    n -= 6;
//    ans += 18;
//}
//if (n >= 1) {
//    n -= 1;
//    ans += 8;
//}
//if (n >= 328) {
//    n -= 328;
//    ans += 198;
//}
//if (n >= 648) {
//    n -= 648;
//    ans += 388;
//}


//int n, m;
//int a[100005];
//int bit[35];
//void solve() {
//    cin >> n >> m;
//    for (int i = 1; i <= n; i++) {
//        cin >> a[i];
//    }
//    for (int i = 0; i <= 34; i++) {
//        bit[i] = 1ll << i;
//    }
//    int z = 0;
//    for (int i = 1; i <= m; i++) {
//        string op;
//        int x;
//        cin >> op >> x;
//        if (op == "AND") {
//            z &= x;
//            for (int i = 0; i <= 34; i++) {
//                bit[i] &= x & (1ll << i);
//            }
//        }
//        else if (op == "OR") {
//            z |= x;
//            for (int i = 0; i <= 34; i++) {
//                bit[i] |= x & (1ll << i);
//            }
//        }
//        else {
//            z ^= x;
//            for (int i = 0; i <= 34; i++) {
//                bit[i] ^= x & (1ll << i);
//            }
//        }
//    }
//    vector<int> ans(n + 1);
//    for (int i = 1; i <= n; i++) {
//        for (int j = 0; j <= 34; j++) {
//            if (a[i] & (1ll << j)) {
//                ans[i] |= bit[j];
//            }
//            else {
//                ans[i] |= z & (1ll << j);
//            }
//        }
//    }
//
//    for (int i = 1; i <= n; i++) {
//        cout << ans[i] << ' ';
//    }
//
//}

//void solve() {
//    cin >> n;
//    for (int i = 1; i <= n; i++) {
//        cin >> a[i];
//    }
//    vector<int> ans(n + 1);
//    int sum = 0;
//    for (int i = 1; i <= n; i++) {
//        ans[i] = a[i] * i - sum;
//        sum += ans[i];
//    }
//    for (int i = 1; i <= n; i++) {
//        cout << ans[i] << ' ';
//    }
//}


//const int N = 200005;
//
//struct node {
//    int mat[3][3];
//}t[N * 4];
//int pp[N], qq[N];
//node ans;
//
//void fun(int a[][3], int b[][3], int c[][3]) {
//    c[1][1] = (a[1][1] & b[1][1]) ^ (a[1][2] & b[2][1]);
//    c[1][2] = (a[1][1] & b[1][2]) ^ (a[1][2] & b[2][2]);
//    c[2][1] = (a[2][1] & b[1][1]) ^ (a[2][2] & b[2][1]);
//    c[2][2] = (a[2][1] & b[1][2]) ^ (a[2][2] & b[2][2]);
//}
//
//void build(int p, int l, int r) {
//    if (l == r) {
//        t[p].mat[1][1] = pp[l];
//        t[p].mat[1][2] = qq[l];
//        t[p].mat[2][1] = (1ll << 62) - 1;
//        t[p].mat[2][2] = 0;
//        return;
//    }
//    int m = (l + r) >> 1;
//    build(2 * p, l, m);
//    build(2 * p + 1, m + 1, r);
//    fun(t[2 * p + 1].mat, t[2 * p].mat, t[p].mat);
//}
//
//void up(int p, int l, int r, int index, int x, int y) {
//    if (l == r) {
//        pp[l] = x;
//        qq[r] = y;
//        t[p].mat[1][1] = pp[index];
//        t[p].mat[1][2] = qq[index];
//        t[p].mat[2][1] = (1ll << 62) - 1;
//        t[p].mat[2][2] = 0;
//        return;
//    }
//    int m = (l + r) >> 1;
//    if (index <= m)up(2 * p, l, m, index, x, y);
//    else up(2 * p + 1, m + 1, r, index, x, y);
//    fun(t[2 * p + 1].mat, t[2 * p].mat, t[p].mat);
//}
//
//void qur(int p, int l, int r, int jl, int jr) {
//    if (jl <= l && r <= jr) {
//        if (ans.mat[1][1] == 0) {
//            ans.mat[1][1] = t[p].mat[1][1];
//            ans.mat[1][2] = t[p].mat[1][2];
//            ans.mat[2][1] = t[p].mat[2][1];
//            ans.mat[2][2] = t[p].mat[2][2];
//        }
//        else {
//            int tt[3][3] = { 0 };
//            tt[1][1] = ans.mat[1][1];
//            tt[1][2] = ans.mat[1][2];
//            tt[2][1] = ans.mat[2][1];
//            tt[2][2] = ans.mat[2][2];
//            fun(t[p].mat, tt, ans.mat);
//        }
//        return;
//    }
//    int m = (l + r) >> 1;
//    if (jl <= m)qur(2 * p, l, m, jl, jr);
//    if (jr > m)qur(2 * p + 1, m + 1, r, jl, jr);
//}
//
//int n, m;
//void solve() {
//    cin >> n >> m;
//    for (int i = 1; i <= n; i++)cin >> pp[i];
//    for (int i = 1; i <= n; i++)cin >> qq[i];
//    build(1, 1, n);
//    while (m--) {
//        int op, pos, x, y, l, r, a0, a1;
//        cin >> op;
//        if (op == 1) {
//            cin >> pos >> x >> y;
//            up(1, 1, n, pos, x, y);
//        }
//        else {
//            cin >> l >> r >> a0 >> a1;
//            ans.mat[1][1] = { 0 };
//            qur(1, 1, n, l, r);
//            int tmp = (ans.mat[1][1] & a1) ^ (ans.mat[1][2] & a0);
//            cout << tmp << '\n';
//        }
//    }
//
//}

//int dp[N];
//void solve() {
//    int n, m; cin >> n >> m;
//    vector<int> p(n + 1), q(n + 1);
//    for (int i = 1; i <= n; i++)cin >> p[i];
//    for (int i = 1; i <= n; i++)cin >> q[i];
//    while (m--) {
//        int op, pos, x, y, l, r, a0, a1;
//        cin >> op;
//        if (op == 1) {
//            cin >> pos >> x >> y;
//            p[pos] = x, q[pos] = y;
//        }
//        else {
//            cin >> l >> r >> a0 >> a1;
//            int len = r - l + 1;
//            vector<int> a(len + 2);
//            a[0] = a0, a[1] = a1;
//            for (int i = 2; i <= len + 1; i++) {
//                a[i] = (a[i - 1] & p[i + l - 2]) ^ (a[i - 2] & q[i + l - 2]);
//            }
//            cout << a[len + 1] << endl;
//        }
//    }
//}


//int n;
//int a[6005];
//int dp[6005];
//int sum[6005];
//int ls[6005][6005];
//void solve() {
//	cin >> n;
//	for (int i = 1; i <= n; i++) {
//		cin >> a[i];
//		sum[i] = sum[i - 1] + a[i];
//	}
//	//ls
//	for (int k = 1; k <= n; k++) {
//		for (int i = n - k + 1; i >= 1; i--) {
//			ls[i][k] = max(ls[i + 1][k], sum[i + k - 1] - sum[i - 1]);
//		}
//	}
//	for (int len = 1; len <= n; len++) {
//		for (int i = 0; i < len; i++) {
//			dp[len] = max(sum[i] + ls[i + 1][len - i], dp[len]);
//		}
//	}
//	for (int i = 1; i <= n; i++) {
//		cout << dp[i] << ' ';
//	}
//	cout << '\n';
//}



//int n;
//string s[100005];
//long double a[100005];
//struct node
//{
//	long double val; string name;
//	bool operator<(const node& x)const {
//		return x.val > val;
//	}
//};
//node e[100005];
//void solve() {
//	cin >> n;
//	priority_queue<node> q;
//	for (int i = 1; i <= n; i++) {
//		cin >> s[i] >> a[i];
//		q.push({ a[i],s[i] });
//	}
//	long double B = 0;
//	set<string> st;
//	while (!q.empty() && st.size() < 30) {
//		auto x = q.top(); q.pop();
//		if (st.count(x.name)) {
//			continue;
//		}
//		else {
//			st.insert(x.name);
//			B += x.val;
//		}
//	}
//	long double R = 0;
//	for (int i = n; i >= 1 && i >= n - 9; i--) {
//		R += a[i];
//	}
//	long double res = (R + B) / 40 + 1e-12;
//	res = (int)((res * 1000 + 5) / 10) / 100.0;
//	printf("%.2lf\n", res);
//}

//int n, m;
//
//void solve() {
//	cin >> n >> m;
//	vector<set<int>> e(n + 1);
//	vector<int> r(n + 1);
//	vector<vector<int>> s(n + 1);
//	set<int> st;
//	for (int i = 1; i <= n; i++) {
//		r[i] = i;
//		st.insert(i);
//		s[i].push_back(i);
//	}
//	for (int i = 1, u, v; i <= m; i++) {
//		cin >> u >> v;
//		e[u].insert(v);
//		e[v].insert(u);
//	}
//
//	auto merge = [&](int u, int v) {
//		if (s[u].size() < s[v].size()) {
//			swap(u, v);
//		}
//		for (int x : s[v]) {
//			r[x] = u;
//			s[u].push_back(x);
//		}
//		st.insert(v);
//		};
//
//	for (int i = 1; i <= n; i++) {
//		for (auto it = st.begin(); it != st.end(); i++) {
//			int x = *it;
//			for (int v : s[x]) {
//				if (!e[i].count(v)) {
//					merge(x, r[i]);
//					it = st.lower_bound(x);
//				}
//			}
//		}
//	}
//
//}